El microprocesador MIPS (página 2)

Partes: 1, 2

lw $t0, 8($s3) ¡MIPS!

La instrucción sw: store word.
D
D
D
D
LOAD: lw
STORE: sw
ALU

La instrucción sw: store word.
Salva la word contenida en $t0 en la posición de memoria 8+$s3.

sw $t0, 8($s3)
La posición de memoria donde
se salvará el contenido de $t0
El registro cuyo contenido
se va a salvar en memoria

Un programa en C que usa las instrucciones lw y sw.
Compilar la expresión siguiente:

//Crear un array de 100 enteros (1 word cada uno)
int A[100];
A[8] = h + A[8];

A[100] está formado por un conjunto de 100 enteros guardados en memoria consecutivamente.
Cada entero (int) ocupa una word
A[100] ocupa 100 words (400 bytes).
Para hacer la suma (+) necesitamos que A[8] y h estén cargados en sendos registros.
Asociaremos h al registro $s2., por ejemplo.
$s3 contiene la dirección de memoria que es la base del array llamado A[].
Cargaremos A[8] en el registro $t0.
Sumaremos $t0 y $s2 y pondremos el resultado en $t0.
Salvaremos el resultado recién obtenido en la dirección de memoria A[8].

Un programa en C que usa lw y sw (ii)
Compilar la expresión siguiente:

A[8] = h + A[8];

Calcular la dirección donde está A[8]
$s3 contiene la dirección base del array A[]
8 x 4 = 32
4bytes/word, $s3(32) representa la dirección del entero A[8]
Cargaremos el contenido de A[8] en el registro $t0.
lw $t0, 32($s3)
Sumamos $s2 y $t0 y guardamos el resultado en $t0.
add $t0, $t0, $s2
Guardamos este resultado en la dirección de memoria de A[8].
sw $t0, $s3(32)

Un programa en C que usa lw y sw (iii)
Compilar la expresión siguiente:
A[8] = h + A[8];
$s3 contiene la dirección base del array A[]
0($s3) “apunta a” A[0]
4($s3) “apunta a” A[1]
8($s3) “apunta a” A[2]
12($s3) “apunta a” A[3] y, así sucesivamente.

lw $t0, 32($s3)
add $t0, $t0, $s2
sw $t0, 32($s3)

Ejemplo de lw y sw más sofisticado
Compilar la expresión siguiente:
A[i] = h + A[i];
Asociamos h al registro $s2, como en el ejemplo precedente.
$s3 contiene la dirección de memoria base de A[].
La variable i la asociamos al registro $s4.
La dirección de memoria de A[i] será:
(Dirección Base de A) + (4 ? i)
¿Por qué multiplicamos por 4?
Cada word tiene 4 bytes
Cada byte ocupa una dirección de memoria ?
add $t1, $s4, $s4 ; i * 2
add $t1, $t1, $t1 ; i * 2 * 2

Ejemplo de lw y sw más sofisticado
Compilar la expresión siguiente:
A[i] = h + A[i];
Formamos la dirección de memoria de A[i]:
add $t2, $t1, $s3

Cargamos el dato dentro del registro $t1, p.ej.:
lw $t1, ($t2)0
Sumamos h a $t1:
add $t1, $s2, $t1
El resultado, esto es, el contenido del registro $t1 lo salvamos en memoria –en la misma dirección de memoria de A[i]:
sw $t1, ($t2)0
(i * 4)
A[]
Dirección de memoria de A[i]

Ejemplo de lw y sw más sofisticado
Compilar la expresión siguiente:
A[i] = h + A[i];

add $t1, $s4, $s4
add $t1, $t1, $t1
add $t2, $t1, $s3
lw $t1, ($t2)0
add $t1, $s2, $t1
sw $t1, ($t2)0

Las instrucciones [cadenas de 32 bits] tienen dirección de memoria.
[Instrucciones y datos se representan del mismo modo].
La forma binaria de las instrucciones MIPS tienen 32 bits (todas).
Cada instrucción ocupa 4 direcciones de memoria seguidas.
Por tanto, una instrucción, al igual que un dato, posée dirección de memoria.
¿Cuál es la dirección de memoria de una instrucción?
Las direcciones de memoria de los datos [Variables, arrays] las representamos simbólicamente con el operador &:
&contador1
Las direcciones de memoria de las instrucciones también se pueden representar simbólicamente mediante una etiqueta:
inicio:

Etiquetas de datos y código en SPIM.
Explicad qué operación lleva a cabo este programa:
.data
Astart:
.word 0x00000060, 0x00000050, 0x00000040
.word 0x00000010, 0x00000000
.word 0x00000000, 0x10101010, 0x20202020
.word 0x30303030, 0x40404040

.text
.globl main

main: la $t0, Astart
li $t1, 4
move $t2, $zero
siguiente:
lw $s0, 0($t0)
beq $s0, $zero, es_cero
add $t2, $t2, $s0
add $t0, $t0, $t1
j siguiente

es_cero: sw $t2, 0($t0)

Direcciones de memoria de instrucciones y de datos: Un ejemplo en C.
if (i == j)
goto fuera;
else
f = g + h;

fuera: f = f – i;

El enfoque siguiente es el correcto: emplear estructuras de programación
if (i != j){
f = g + h;
}

f = f – i;
Este enfoque no es correcto

Producción de un programa.

Producción de un programa: Denominación de los ficheros intermedios.

Intro. Codificación de instrucciones: add
La siguiente instrucción está representada en lenguaje de ensamblaje:

add $t0, $s1, $s2

El computador no “entiende” las instrucciones en este formato fuente.
Sin embargo, esta representación es conveniente para las personas.
El programa que traduce el texto escrito en lenguaje de ensamblaje es el programa ensamblador.
El ensamblador traduce el texto fuente a “texto o código objeto” (Una forma de código máquina).
El texto objeto está “lleno” de instrucciones en forma binaria.

Y, para terminar esta sección: Dos principios fundamentales.
Las instrucciones se representan en binario, igual que los datos numéricos.

Los programas y los datos que manejan, se almacenan en el mismo sitio: la memoria.

Instrucciones de salto condicional
Flujo de ejecución secuencial:
PC <- PC + 4
1000, 1004, 1008, 1012,…
Salto a la dirección 32000:
1024, 1028, 32000…
beq $t0, $t1, destino0
Branch if equal
Salta a destino0 si $t0 es igual $t1
bne $s3, $v0, destino1
Branch if non-equal
Salta a destino1 si $s3 es distinto de $v0

Compilación de una estructura if-then-else (I)
Las variables f, g, h, i y j están asociadas a los registros $s0 a $s4.

if (i == j)
f = g + h;
else
f = g – h;

Comprobar la condición opuesta porque:
b (branch)
no es ejecutar este bloque
es saltar a un bloque

bne $s3, $s4, else
add $s0, $s1, $s2
j exit #Salto incondicional.
else: sub $s0, $s1, $s2
exit:…
Compilación De Una Estructura if-then-else (II)
if (i == j)
f = g + h;
else
f = g – h;

Estructuras repetitivas.
Un bloque de instrucciones es ejecutado una vez tras otra:
Mientras cierta condición sea verdadera: Que j sea distinto de 100.
En cada iteración se modifica el valor empleado para evaluar la condición (j=j+5).
En algún momento, el valor hará que la condición sea falsa y que el bucle no se repita más veces: Salto a Exit.
¿j != 100?
Bloque de
Instrucciones
Evalúa j, ejemplo:
j = j + 5;
Verdadero
Falso
j = 0;
Etiqueta Exit

Compilación de un bucle whileEjemplo 2.
int main(){
const int k = -1, i = 0;
static int vector[]={
-1,-1,-1,
-1,-1, 0,
0, 0, 1
};

while(vector[i] == k){
i = i + 1;
}
}
¿vector[i] == k?
i = i + 1;
V
F

Compilación de un bucle while.Ejemplo 3.
Traducid este programa al leng. de ensamblaje MIPS:

int main(){
static int vector[20]={
0,1,0,1,0,1,0,1,0,1,
0,1,0,1,0,0,0,0,0,0
};

int i = 0, j = 2, k = 1;

while (vector[i] == k){
i = i + j;
}

}
¿vector[i]==k?
i = i + j;
V
F

Asumimos que:
i, j, k? $s3, $s4, $s5
vector[]?$s6
La dirección de comienzo del array vector se encuentra en $s6.

Cargar el elemento vector[i] en un registro temporal:
#Etiqueta de comienzo del bucle:
inicio_while:
add $t1, $s3, $s3 #i*2
add $t1, $t1, $t1 #i*4
add $t1, $t1, $s6 #vector+4*i
lw $t0, 0($t1) #$t0 ? save[i]

Compilación de un bucle while Ejemplo 3.

int main(){

static int vector[20]={
0,1,0,1,0,1,0,1,0,1,
0,1,0,1,0,0,0,0,0,0
};

int i = 0, j = 2, k = 1;

while (vector[i] == k){
i = i + j;
}

}

i, j, k? $s3, $s4, $s5
save?$s6
save[i]?$t0

2. Comparar save[i] con k:
;Saltar a fin_while
;en caso de que $t0 != $s5
bne $t0, $s5, fin_while
3. Bloque falso (con respecto a bne):
add $s3, $s3, $s4 ; i = i+j;
4. Saltar al comienzo:
j inicio_while

fin_while: … ; Resto del programa
…
Compilación de un bucle while, Ejemplo 3.

int main(){
static int vector[20]={
0,1,0,1,0,1,0,1,0,1,
0,1,0,1,0,0,0,0,0,0
};

int i = 0, j = 2, k = 1;

while (vector[i] == k){
i = i + j;
}

}

Compilación de un bucle while.Ejemplo 4.
Traducid este programa al leng. de ensamblaje MIPS:

int main(){
static int vector[20]={
0,1,0,1,0,1,0,1,0,1,
0,1,0,1,0,0,0,0,0,0
};

int i = 1, j = 2, k = 1;

while (vector[i] == k){
i = i + j;
}

}
¿vector[i]==k?
i = i + j;
V
F

Compilación de un bucle while, Ejemplo 3.

Compilación de un bucle while Ejemplo 3.

Comparación de magnitud: x < y, x ? y
El test igualdad (beq) y el test des-igualdad (bne) son muy comunes.

Los tests mayor que y menor que, son también muy comunes.

Comparación de magnitud: x < y, x ? y

¿Cómo se hace para determinar si $x es menor que $y?
Usaremos una instrucción nueva llamada slt (Set-on-less-than).
“Poner [el primer registro] a 1 si [el segundo registro] es menor que [el tercer registro]”.
slt $r, $x, $y
Cuando finaliza la instrucción:
Si $r contiene un 1 ? $x < $y
Si $r contiene un 0 ? $x ? $y